/*
###################################################################
# LINDO-API
# Sample Programs
# Copyright (c) 2001-2002
#
# LINDO Systems, Inc. 312.988.7422
# 1415 North Dayton St. info@lindo.com
# Chicago, IL 60622 http://www.lindo.com
###################################################################
File : ex_nlp1.java
Purpose: Solve a NLP using the black-box style interface.
Model : A nonlinear model with multiple local minimizers.
minimize f(x,y) = 3*(1-x)^2*exp(-(x^2) - (y+1)^2)
- 10*(x/5 - x^3 - y^5).*exp(-x^2-y^2)
- 1/3*exp(-(x+1)^2 - y^2);
subject to
x^2 + y <= 6;
x + y^2 <= 6;
y integer
*/
import com.lindo.*;
class ex_userdata
{
int counter;
}
public class ex_nlp1 extends Lindo
{
private static int nErrorCode[] = new int[1];
private static StringBuffer cErrorMessage = new StringBuffer();
private static StringBuffer cLicenseKey = new StringBuffer();
private static ex_userdata kkt = new ex_userdata();
private static ex_userdata fde = new ex_userdata();
/*
* Standard callback function to display local solutions
*/
private static int local_sol_log(int model, int iLoc, Object pls)
{
ex_nlp1 nls = (ex_nlp1) pls;
ex_userdata _kkt = (ex_userdata) nls.kkt;
int iter[] = new int[1];
int mip_iter[] = new int[1];
double pobj[] = new double[1];
if (iLoc==LSLOC_LOCAL_OPT)
{
LSgetCallbackInfo(model,iLoc,LS_IINFO_NLP_ITER,iter);
LSgetCallbackInfo(model,iLoc,LS_IINFO_MIP_NLP_ITER,mip_iter);
LSgetCallbackInfo(model,iLoc,LS_DINFO_POBJ,pobj);
System.out.println("@local solution " + _kkt.counter++ +
" mip_iter = " + mip_iter[0] +
" iter = " +iter[0] +
" obj = " + pobj[0]);
}
else if (iLoc==LSLOC_CONOPT)
{
LSgetCallbackInfo(model,iLoc,LS_IINFO_NLP_ITER,iter);
LSgetCallbackInfo(model,iLoc,LS_IINFO_MIP_NLP_ITER,mip_iter);
LSgetCallbackInfo(model,iLoc,LS_DINFO_POBJ,pobj);
System.out.println(" " +
" mip_iter = " + mip_iter[0] +
" iter = " + iter[0] +
" obj = " + pobj[0]);
}
return 0;
} /*local_sol_log*/
private static double g1( double X, double Y)
{
return Math.exp( -Math.pow(X ,2) - Math.pow(Y+1,2) );
}
private static double g2( double X, double Y)
{
return Math.exp( -Math.pow(X ,2) - Math.pow(Y,2) );
}
private static double g3( double X, double Y)
{
return Math.exp( -Math.pow(X+1 ,2) - Math.pow(Y,2) );
}
private static double f1( double X, double Y)
{
return Math.pow(1-X ,2) ;
}
private static double f2( double X, double Y)
{
return ( X/5 - Math.pow(X ,3) - Math.pow(Y,5) );
}
/*
* Callback function to evaluate functional values
*/
private static int Funcalc8 (int pModel, Object pUserData,
int nRow ,double pdX[],
int nJDiff,double dXJBase,
double pdFuncVal[],int pReserved[])
{
ex_nlp1 nls = (ex_nlp1) pUserData;
ex_userdata _fde = (ex_userdata) nls.fde;
_fde.counter++;
double val=0.0, X = pdX[0], Y = pdX[1];
int nerr=0;
/* compute objective's functional value*/
if (nRow==-1)
val = 3*f1(X,Y)*g1(X,Y) - 10*f2(X,Y)*g2(X,Y) - g3(X,Y)/3;
/* compute constaint 0's functional value */
else if (nRow==0)
val = X*X + Y - 6.0;
/* compute constaint 1's functional value */
else if (nRow==1)
val = X + Y*Y - 6.0;
pdFuncVal[0]=val;
return nerr;
} /*Funcalc8*/
// Generalized error Reporting function
private static void APIErrorCheck(int pEnv[] )
{
if(0 != nErrorCode[0])
{
LSgetErrorMessage(pEnv[0], nErrorCode[0], cErrorMessage);
System.out.println("\nError " + nErrorCode[0] + ": " + cErrorMessage);
System.out.println();
System.exit(1);
}
}
static
{
// The runtime system executes a class's static
// initializer when it loads the class.
System.loadLibrary("lindojni");
}
public static void main (String[] args)
{
ex_nlp1 ls = new ex_nlp1();
/* Number of constraints */
int nM = 2;
/* Number of variables */
int nN = 2;
/* The number of nonzeros in the constraint matrix */
int nNZ = 4;
/* declare an instance of the LINDO environment object */
int pEnv[] = new int[1];
/* declare an instance of the LINDO model object */
int pModel[] = new int[1];
int nStatus[] = new int[1];
/* >>> Step 1 <<< Read license file and create a LINDO environment. */
nErrorCode[0] = ls.LSloadLicenseString("../../../license/license.h",cLicenseKey);
APIErrorCheck(pEnv);
pEnv[0] = ls.LScreateEnv(nErrorCode, cLicenseKey.toString());
if ( nErrorCode[0] == ls.LSERR_NO_VALID_LICENSE)
{
System.out.println("Invalid License Key!\n");
System.exit(1);
}
APIErrorCheck(pEnv);
/* >>> Step 2 <<< Create a model in the environment. */
pModel[0] = ls.LScreateModel ( pEnv[0], nErrorCode);
APIErrorCheck(pEnv);
/* >>> Step 3 <<< Specify the model.
/* The direction of optimization */
int nDir = ls.LS_MIN;
/* The objective's constant term */
double dObjConst = 0.;
/* The coefficients of the objective function */
double adC[] = new double[] { 0, 0};
/* The right-hand sides of the constraints */
double adB[] = new double[] { 0, 0};
/* The indices of the first nonzero in each column */
int anBegCol[] = new int[]{ 0, 2, 4};
/* The length of each column. Since we aren't leaving
any blanks in our matrix, we can set this to NULL */
int anLenCol[] = new int[] { 2 , 2};
/* The nonzero coefficients */
double adA[] = new double[] { 0, 1, 1, 0};
/* The row indices of the nonzero coefficients */
int anRowX[] = new int[]{ 0, 1, 0, 1};
/* Simple upper and lower bounds on the variables.
By default, all variables have a lower bound of zero
and an upper bound of infinity. Therefore pass NULL
pointers in order to use these default values. */
double pdLower[] = new double[] { -3, -3};
double pdUpper[] = new double[] { +3, +3};
/* The constraint types */
String acConTypes = "LL";
String acVarTypes = "CI";
/* We have now assembled a full description of the model.
We pass this information to LSloadLPData with the
following call. */
nErrorCode[0] = ls.LSloadLPData( pModel[0], nM, nN, nDir,
dObjConst, adC, adB, acConTypes, nNZ, anBegCol,
anLenCol, adA, anRowX, pdLower, pdUpper);
APIErrorCheck(pEnv);
ls.LSloadVarType(pModel[0],acVarTypes);
/* The number of nonlinear variables in each column */
anLenCol[0]=1; anLenCol[1]=1;
/* The indices of the first nonlinear variable in each column */
anBegCol[0]=0; anBegCol[1]=1; anBegCol[2]=2;
/* The indices of nonlinear constraints */
anRowX[0]=0;
anRowX[1]=1;
/* The indices of variables that are nonlinear in the objective*/
int Nobjndx[] = new int[]{ 0, 1};
/* Number nonlinear variables in cost. */
int Nnlobj = 2;
/* Load the nonlinear structure */
nErrorCode[0]=ls.LSloadNLPData(pModel[0],anBegCol,anLenCol,null,
anRowX,Nnlobj,Nobjndx,null);
APIErrorCheck(pEnv);
/* Install a callback function */
nErrorCode[0] = ls.LSsetCallback(pModel[0],"local_sol_log",ls);
APIErrorCheck(pEnv);
/* Set the print level to 1 */
nErrorCode[0] = ls.LSsetModelIntParameter(pModel[0],ls.LS_IPARAM_NLP_PRINTLEVEL,1);
APIErrorCheck(pEnv);
/* Install the routine that will calculate the function values. */
nErrorCode[0] = ls.LSsetFuncalc(pModel[0],"Funcalc8",ls);
APIErrorCheck(pEnv);
nErrorCode[0] = ls.LSsetModelIntParameter(pModel[0],ls.LS_IPARAM_NLP_SOLVER,
ls.LS_NMETHOD_MSW_GRG);
nErrorCode[0] = ls.LSsetModelIntParameter(pModel[0],ls.LS_IPARAM_NLP_MAXLOCALSEARCH,3);
/* >>> Step 4 <<< Perform the optimization */
nErrorCode[0] = ls.LSsolveMIP( pModel[0], nStatus);
System.out.println("Status = " + nStatus[0]);
APIErrorCheck(pEnv);
/* >>> Step 5 <<< Retrieve the solution */
int i;
double adX[] = new double[2], dObj[] = new double[1];
int minlp_iter[] = new int[1];
int misim_iter[] = new int[1];
/* Get the value of the objective */
nErrorCode[0] = ls.LSgetInfo(pModel[0], LS_DINFO_MIP_OBJ, dObj) ;
APIErrorCheck(pEnv);
nErrorCode[0] = ls.LSgetInfo(pModel[0], LS_IINFO_MIP_NLP_ITER, minlp_iter) ;
APIErrorCheck(pEnv);
nErrorCode[0] = ls.LSgetInfo(pModel[0], LS_IINFO_MIP_SIM_ITER, misim_iter) ;
APIErrorCheck(pEnv);
System.out.print("Objective Value = " + dObj[0] + "\n");
/* Get the variable values */
nErrorCode[0] = ls.LSgetMIPPrimalSolution (pModel[0], adX);
APIErrorCheck(pEnv);
System.out.println("Primal values");
for (i = 0; i < nN; i++) System.out.println("\tx["+i+"] = "+adX[i]);
System.out.print("\n");
/* >>> Step 6 <<< Delete the LINDO environment */
nErrorCode[0] = ls.LSdeleteEnv( pEnv);
System.out.println("Number of nonlinear iters = " + minlp_iter[0]);
System.out.println("Number of simplex iters = " + misim_iter[0]);
System.out.println("Number of function evaluations = " + fde.counter);
System.out.println("Number of KKT points found = " + kkt.counter);
System.out.println("Done!\n");
}
}
|
